function error_analysis()
% ERROR_ANALYSIS 误差分析示例
% 
% 演示绝对误差、相对误差和误差传播

fprintf('=== 误差分析 ===\n\n');

%% 1. 绝对误差和相对误差
fprintf('1. 绝对误差和相对误差\n');
true_value = pi;
approx_value = 22/7;  % π的近似值

abs_error = abs(approx_value - true_value);
rel_error = abs_error / abs(true_value);

fprintf('真实值: π = %.15f\n', true_value);
fprintf('近似值: 22/7 = %.15f\n', approx_value);
fprintf('绝对误差: %e\n', abs_error);
fprintf('相对误差: %e (%.6f%%)\n', rel_error, rel_error * 100);

%% 2. 函数求值的误差传播
fprintf('\n2. 函数求值的误差传播\n');
fprintf('考虑函数 f(x) = sin(x) 在 x = π/6 处的误差传播\n');

x_exact = pi/6;
x_perturbed = x_exact + 1e-6;  % 输入有小扰动

f_exact = sin(x_exact);
f_perturbed = sin(x_perturbed);

input_error = abs(x_perturbed - x_exact);
output_error = abs(f_perturbed - f_exact);

% 理论误差（使用导数）
df_dx = cos(x_exact);  % f'(x) = cos(x)
theoretical_error = abs(df_dx) * input_error;

fprintf('精确输入: x = π/6 = %.15f\n', x_exact);
fprintf('扰动输入: x = %.15f\n', x_perturbed);
fprintf('输入误差: %e\n', input_error);
fprintf('输出误差: %e\n', output_error);
fprintf('理论误差: %e\n', theoretical_error);
fprintf('误差放大因子: %.6f\n', output_error / input_error);

%% 3. 矩阵运算的误差传播
fprintf('\n3. 矩阵运算的误差传播\n');
fprintf('考虑矩阵乘法 C = A * B 的误差传播\n');

A = [1, 2; 3, 4];
B = [5, 6; 7, 8];
C_exact = A * B;

% 给A添加小扰动
delta_A = 1e-10 * randn(size(A));
A_perturbed = A + delta_A;
C_perturbed = A_perturbed * B;

error_A = norm(delta_A, 'fro');
error_C = norm(C_perturbed - C_exact, 'fro');

fprintf('||δA||_F = %e\n', error_A);
fprintf('||δC||_F = %e\n', error_C);
fprintf('相对误差放大: %.6f\n', (error_C / norm(C_exact, 'fro')) / (error_A / norm(A, 'fro')));

%% 4. 数值微分的误差分析
fprintf('\n4. 数值微分的误差分析\n');
fprintf('使用有限差分近似 f''(x) ≈ [f(x+h) - f(x)]/h\n');

f = @(x) exp(x);  % 函数 f(x) = e^x
df_exact = @(x) exp(x);  % 精确导数

x0 = 1;
h_values = logspace(-16, -1, 16);  % 从 10^-16 到 10^-1
errors = zeros(size(h_values));

for i = 1:length(h_values)
    h = h_values(i);
    df_approx = (f(x0 + h) - f(x0)) / h;
    df_true = df_exact(x0);
    errors(i) = abs(df_approx - df_true);
end

% 找到最优步长
[min_error, min_idx] = min(errors);
optimal_h = h_values(min_idx);

fprintf('在 x = %g 处计算 e^x 的导数\n', x0);
fprintf('精确值: %g\n', df_exact(x0));
fprintf('最优步长: h = %e\n', optimal_h);
fprintf('最小误差: %e\n', min_error);

% 绘制误差曲线
figure('Name', '数值微分误差分析');
loglog(h_values, errors, 'b-o', 'LineWidth', 2, 'MarkerSize', 6);
hold on;
loglog(optimal_h, min_error, 'ro', 'MarkerSize', 10, 'LineWidth', 2);
xlabel('步长 h');
ylabel('绝对误差');
title('数值微分误差 vs 步长');
grid on;
legend('误差曲线', '最优点', 'Location', 'best');

%% 5. 病态问题示例
fprintf('\n5. 病态问题示例\n');
fprintf('Hilbert矩阵的条件数\n');

for n = 3:8
    H = hilb(n);  % n×n Hilbert矩阵
    cond_num = cond(H);
    fprintf('H_%d 的条件数: %e\n', n, cond_num);
end

fprintf('\n随着矩阵维数增加，Hilbert矩阵变得极度病态\n');

end